home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / boot / diskBoot.OpenProm / RCS / fsIndex.c,v < prev    next >
Text File  |  1989-06-16  |  11KB  |  481 lines
  1. head     1.6;
  2. branch   ;
  3. access   ;
  4. symbols  ;
  5. locks    ; strict;
  6. comment  @ * @;
  7.  
  8.  
  9. 1.6
  10. date     89.06.16.08.30.08;  author brent;  state Exp;
  11. branches ;
  12. next     1.5;
  13.  
  14. 1.5
  15. date     89.01.06.08.14.41;  author brent;  state Exp;
  16. branches ;
  17. next     1.4;
  18.  
  19. 1.4
  20. date     87.05.08.17.45.40;  author brent;  state Exp;
  21. branches ;
  22. next     1.3;
  23.  
  24. 1.3
  25. date     86.07.21.09.36.35;  author brent;  state Exp;
  26. branches ;
  27. next     1.2;
  28.  
  29. 1.2
  30. date     86.07.18.11.58.32;  author nelson;  state Exp;
  31. branches ;
  32. next     1.1;
  33.  
  34. 1.1
  35. date     86.07.18.09.33.18;  author brent;  state Exp;
  36. branches ;
  37. next     ;
  38.  
  39.  
  40. desc
  41. @Block index chasing.
  42. @
  43.  
  44.  
  45. 1.6
  46. log
  47. @Updated to the new device interface
  48. @
  49. text
  50. @/* 
  51.  * fsIndex.c --
  52.  *
  53.  *    Routines to allow moving through a files block pointers.
  54.  *
  55.  * Copyright 1986 Regents of the University of California
  56.  * All rights reserved.
  57.  */
  58.  
  59. #ifdef notdef
  60. static char rcsid[] = "$Header: /sprite/src/boot/scsiDiskBoot.new/RCS/fsIndex.c,v 1.5 89/01/06 08:14:41 brent Exp Locker: brent $ SPRITE (Berkeley)";
  61. #endif not lint
  62.  
  63. #include "sprite.h"
  64. #include "fsBoot.h"
  65. #include "byte.h"
  66.  
  67. char    firstBlockBuffer[FS_BLOCK_SIZE];
  68. char    secondBlockBuffer[FS_BLOCK_SIZE];
  69.  
  70.  
  71. /*
  72.  *----------------------------------------------------------------------
  73.  *
  74.  * MakePtrAccessible --
  75.  *
  76.  *    Make the block pointer in the file descriptor accessible.  This
  77.  *    may entail reading in indirect blocks and locking them down in the
  78.  *    cache.
  79.  *
  80.  * Results:
  81.  *    None.
  82.  *
  83.  * Side effects:
  84.  *    Indirect blocks are locked down in the cache.
  85.  *
  86.  *----------------------------------------------------------------------
  87.  */
  88.  
  89. static ReturnStatus
  90. MakePtrAccessible(handlePtr, indexInfoPtr, descPtr)
  91.     register    FsLocalFileIOHandle     *handlePtr;
  92.     register    BlockIndexInfo      *indexInfoPtr;
  93.     register    FsFileDescriptor *descPtr;
  94. {
  95.     register     int          *blockAddrPtr;
  96.  
  97.     /* 
  98.      * Read in the first block.
  99.      */
  100.  
  101.     if (indexInfoPtr->firstBlockNil) {
  102.     FsDeviceBlockIO(FS_READ, &fsDevice,
  103.               descPtr->indirect[indexInfoPtr->indexType],
  104.               FS_FRAGMENTS_PER_BLOCK, firstBlockBuffer);
  105.     }
  106.  
  107.     blockAddrPtr = 
  108.     (int *) (firstBlockBuffer + sizeof(int) * indexInfoPtr->firstIndex);
  109.  
  110.     if (indexInfoPtr->indexType == FS_INDIRECT) {
  111.     indexInfoPtr->blockAddrPtr = blockAddrPtr;
  112.     return(SUCCESS);
  113.     }
  114.  
  115.     /* 
  116.      * Get the second level block.
  117.      */
  118.  
  119.     FsDeviceBlockIO(FS_READ, &fsDevice, *blockAddrPtr,
  120.                FS_FRAGMENTS_PER_BLOCK, secondBlockBuffer);
  121.     indexInfoPtr->blockAddrPtr = 
  122.     (int *) (secondBlockBuffer + sizeof(int) * indexInfoPtr->secondIndex);
  123.  
  124.     return(SUCCESS);
  125. }
  126.  
  127.  
  128. /*
  129.  *----------------------------------------------------------------------
  130.  *
  131.  * FsGetFirstIndex --
  132.  *
  133.  *    Initialize the index structure.  This will set up the index info
  134.  *    structure so that it contains a pointer to the desired block pointer.
  135.  *
  136.  * Results:
  137.  *    A status indicating whether there was sufficient space to allocate
  138.  *    indirect blocks.
  139.  *
  140.  * Side effects:
  141.  *    The index structure is initialized.
  142.  *
  143.  *----------------------------------------------------------------------
  144.  */
  145.  
  146. ReturnStatus
  147. FsGetFirstIndex(handlePtr, blockNum, indexInfoPtr)
  148.     register FsLocalFileIOHandle        *handlePtr;    /* Handle for file that are 
  149.                           indexing. */
  150.     register int        blockNum;      /* Where to start indexing. */
  151.     register BlockIndexInfo *indexInfoPtr; /* Index structure to initialize.*/
  152. {
  153.     register FsFileDescriptor *descPtr;
  154.     register int          indirectBlock;
  155.  
  156.     descPtr = handlePtr->descPtr;
  157.     indexInfoPtr->firstBlockNil = TRUE;
  158.     indexInfoPtr->blockNum = blockNum;
  159.  
  160.     if (blockNum < FS_NUM_DIRECT_BLOCKS) {
  161.     /*
  162.      * This is a direct block.
  163.      */
  164.     indexInfoPtr->indexType = FS_DIRECT;
  165.     indexInfoPtr->blockAddrPtr = &descPtr->direct[blockNum];
  166.     return(SUCCESS);
  167.     }
  168.  
  169.     /*
  170.      * Is an indirect block.
  171.      */
  172.  
  173.     blockNum -= FS_NUM_DIRECT_BLOCKS;
  174.     indirectBlock = blockNum / FS_INDICES_PER_BLOCK;
  175.     if (indirectBlock == 0) {
  176.     /*
  177.      * This is a singly indirect block.
  178.      */
  179.     indexInfoPtr->indexType = FS_INDIRECT;
  180.     indexInfoPtr->firstIndex = blockNum;
  181.     } else {
  182.     /*
  183.      * This a doubly indirect block.
  184.      */
  185.     indexInfoPtr->indexType = FS_DBL_INDIRECT;
  186.     indexInfoPtr->firstIndex = indirectBlock - 1;
  187.     indexInfoPtr->secondIndex = blockNum -
  188.                     indirectBlock * FS_INDICES_PER_BLOCK;
  189.     }
  190.  
  191.     /*
  192.      * Finish off by making the block pointer accessible.  This may include
  193.      * reading indirect blocks into the cache.
  194.      */
  195.  
  196.     return(MakePtrAccessible(handlePtr, indexInfoPtr, descPtr));
  197. }
  198.  
  199.  
  200. /*
  201.  *----------------------------------------------------------------------
  202.  *
  203.  * FsGetNextIndex --
  204.  *
  205.  *    Put the correct pointers in the index structure to access the
  206.  *    block after the current block.
  207.  *
  208.  * Results:
  209.  *    A status indicating whether there was sufficient space to allocate
  210.  *    indirect blocks if they were needed.
  211.  *
  212.  * Side effects:
  213.  *    The allocation structure is modified.
  214.  *
  215.  *----------------------------------------------------------------------
  216.  */
  217.  
  218. ReturnStatus
  219. FsGetNextIndex(handlePtr, indexInfoPtr)
  220.     register FsLocalFileIOHandle       *handlePtr;    /* Handle for file that is being
  221.                           indexed. */
  222.     register BlockIndexInfo *indexInfoPtr; /* Index structure to set up. */
  223. {
  224.     register Boolean          accessible = FALSE;
  225.     register FsFileDescriptor *descPtr;
  226.  
  227.     descPtr = handlePtr->descPtr;
  228.     indexInfoPtr->blockNum++;
  229.  
  230.     /*
  231.      * Determine whether we are now in direct, indirect or doubly indirect
  232.      * blocks.
  233.      */
  234.  
  235.     switch (indexInfoPtr->indexType) {
  236.     case FS_DIRECT:
  237.         if (indexInfoPtr->blockNum < FS_NUM_DIRECT_BLOCKS) {
  238.         /*
  239.          * Still in the direct blocks.
  240.          */
  241.         indexInfoPtr->blockAddrPtr++;
  242.         accessible = TRUE;
  243.         } else {
  244.         /*
  245.          * Moved into indirect blocks.
  246.          */
  247.         indexInfoPtr->indexType = FS_INDIRECT;
  248.         indexInfoPtr->firstIndex = 0;
  249.         }
  250.         break;
  251.     case FS_INDIRECT:
  252.         if (indexInfoPtr->blockNum < 
  253.             FS_NUM_DIRECT_BLOCKS + FS_INDICES_PER_BLOCK) {
  254.         /*
  255.          * Still in singly indirect blocks.
  256.          */
  257.         indexInfoPtr->blockAddrPtr++;
  258.         accessible = TRUE;
  259.         break;
  260.        } else {
  261.         /*
  262.          * Moved into doubly indirect blocks.
  263.          */
  264.         indexInfoPtr->firstIndex = 0;
  265.         indexInfoPtr->secondIndex = 0;
  266.         indexInfoPtr->indexType = FS_DBL_INDIRECT;
  267.         indexInfoPtr->firstBlockNil = TRUE;
  268.         }
  269.         break;
  270.     case FS_DBL_INDIRECT:
  271.         indexInfoPtr->secondIndex++;
  272.         if (indexInfoPtr->secondIndex == FS_INDICES_PER_BLOCK) {
  273.         indexInfoPtr->firstIndex++;
  274.         indexInfoPtr->secondIndex = 0;
  275.         } else {
  276.         indexInfoPtr->blockAddrPtr++;
  277.         accessible = TRUE;
  278.         }
  279.         break;
  280.     }
  281.  
  282.     /*
  283.      * Make the block pointers accessible if necessary.
  284.      */
  285.  
  286.     if (!accessible) {
  287.     return(MakePtrAccessible(handlePtr, indexInfoPtr, descPtr));
  288.     } else {
  289.     return(SUCCESS);
  290.     }
  291. }
  292. @
  293.  
  294.  
  295. 1.5
  296. log
  297. @New include files and constants due to source reorganization
  298. @
  299. text
  300. @d10 2
  301. a11 2
  302. #ifndef lint
  303. static char rcsid[] = "$Header: fsIndex.c,v 1.4 87/05/08 17:45:40 brent Exp $ SPRITE (Berkeley)";
  304. d15 1
  305. a15 2
  306. #include "fs.h"
  307. #include "fsDisk.h"
  308. a16 2
  309. #include "fsIndex.h"
  310. #include "fsOpTable.h"
  311. d42 1
  312. a42 1
  313.     register    FsHandle     *handlePtr;
  314. d53 1
  315. a53 1
  316.     FsBlockIO(FS_READ, &handlePtr->device,
  317. d70 1
  318. a70 1
  319.     FsBlockIO(FS_READ, &handlePtr->device, *blockAddrPtr,
  320. d99 1
  321. a99 1
  322.     register FsHandle        *handlePtr;    /* Handle for file that are 
  323. d171 1
  324. a171 1
  325.     register FsHandle       *handlePtr;    /* Handle for file that is being
  326. @
  327.  
  328.  
  329. 1.4
  330. log
  331. @Updated to reflect changes in fs header files
  332. @
  333. text
  334. @d11 1
  335. a11 1
  336. static char rcsid[] = "$Header: fsIndex.c,v 1.3 86/07/21 09:36:35 brent Exp $ SPRITE (Berkeley)";
  337. a15 1
  338. #include "fsInt.h"
  339. d56 1
  340. a56 1
  341.     FsBlockIO(FS_READ, &handlePtr->rec.device,
  342. d73 1
  343. a73 1
  344.     FsBlockIO(FS_READ, &handlePtr->rec.device, *blockAddrPtr,
  345. d110 1
  346. a110 1
  347.     descPtr = (FsFileDescriptor *) handlePtr->nameToken;
  348. d181 1
  349. a181 1
  350.     descPtr = (FsFileDescriptor *) handlePtr->nameToken;
  351. @
  352.  
  353.  
  354. 1.3
  355. log
  356. @changed interface to FsBlockIO
  357. @
  358. text
  359. @d11 1
  360. a11 1
  361. static char rcsid[] = "$Header: fsIndex.c,v 1.2 86/07/18 11:58:32 nelson Exp $ SPRITE (Berkeley)";
  362. d57 1
  363. a57 1
  364.     FsBlockIO(FS_READ, &handlePtr->device,
  365. d74 1
  366. a74 1
  367.     FsBlockIO(FS_READ, &handlePtr->device, *blockAddrPtr,
  368. d111 1
  369. a111 1
  370.     descPtr = (FsFileDescriptor *) handlePtr->domainToken;
  371. d182 1
  372. a182 1
  373.     descPtr = (FsFileDescriptor *) handlePtr->domainToken;
  374. @
  375.  
  376.  
  377. 1.2
  378. log
  379. @Trimmed.
  380. @
  381. text
  382. @d11 1
  383. a11 1
  384. static char rcsid[] = "$Header: fsIndex.c,v 1.1 86/07/18 09:33:18 brent Exp $ SPRITE (Berkeley)";
  385. d20 1
  386. d57 2
  387. a58 1
  388.     FsBlockIO(handlePtr, descPtr->indirect[indexInfoPtr->indexType],
  389. d74 2
  390. a75 2
  391.     FsBlockIO(handlePtr, *blockAddrPtr, FS_FRAGMENTS_PER_BLOCK,
  392.           secondBlockBuffer);
  393. @
  394.  
  395.  
  396. 1.1
  397. log
  398. @Initial revision
  399. @
  400. text
  401. @d11 1
  402. a11 1
  403. static char rcsid[] = "$Header: fsIndex.c,v 1.8 86/07/16 14:21:13 nelson Exp $ SPRITE (Berkeley)";
  404. d46 1
  405. a46 1
  406.     register    BlockIndexInfo *indexInfoPtr;
  407. d49 1
  408. a49 1
  409.     register     int          blockAddr;
  410. a50 6
  411.     if (indexInfoPtr->indexType == FS_INDIRECT) {
  412.     blockAddr = descPtr->indirect[0];
  413.     } else {
  414.     blockAddr = descPtr->indirect[1];
  415.     }
  416.  
  417. d55 3
  418. a57 4
  419.     if (indexInfoPtr->firstBlockPtr == (Address) NIL) {
  420.     indexInfoPtr->firstBlockPtr = firstBlockBuffer;
  421.     FsFileBlockIO(handlePtr, blockAddr, FS_FRAGMENTS_PER_BLOCK,
  422.                  firstBlockBuffer);
  423. d60 2
  424. a61 2
  425.     blockAddr = 
  426.     *(int *) (firstBlockBuffer + sizeof(int) * indexInfoPtr->firstIndex);
  427. d64 1
  428. a64 1
  429.     indexInfoPtr->blockAddr = blockAddr;
  430. d69 1
  431. a69 1
  432.      * Lock the second level block into the cache.
  433. d72 4
  434. a75 4
  435.     FsFileBlockIO(handlePtr, blockAddr, FS_FRAGMENTS_PER_BLOCK,
  436.                  secondBlockBuffer);
  437.     indexInfoPtr->blockAddr = 
  438.     *(int *) (secondBlockBuffer + sizeof(int) * indexInfoPtr->secondIndex);
  439. d101 3
  440. a103 3
  441.     FsHandle              *handlePtr;    /* Handle for file that are 
  442.                         indexing. */
  443.     int                  blockNum;      /* Where to start indexing. */
  444. d107 1
  445. a107 1
  446.     int                  indirectBlock;
  447. d110 1
  448. a110 2
  449.     indexInfoPtr->firstBlockPtr = (Address) NIL;
  450.     indexInfoPtr->secondBlockPtr = secondBlockBuffer;
  451. d118 1
  452. a118 2
  453.     indexInfoPtr->firstIndex = blockNum;
  454.     indexInfoPtr->blockAddr = descPtr->direct[blockNum];
  455. d173 2
  456. a174 2
  457.     FsHandle              *handlePtr;    /* Handle for file that is being
  458.                         indexed. */
  459. d177 2
  460. a178 2
  461.     Boolean            accessible = FALSE;
  462.     register FsFileDescriptor    *descPtr;
  463. d194 1
  464. a194 3
  465.         indexInfoPtr->firstIndex++;
  466.         indexInfoPtr->blockAddr = 
  467.                 descPtr->direct[indexInfoPtr->firstIndex];
  468. d210 1
  469. a210 3
  470.         indexInfoPtr->firstIndex++;
  471.         indexInfoPtr->blockAddr = *(int *) (firstBlockBuffer + 
  472.                 sizeof(int) * indexInfoPtr->firstIndex);
  473. d220 1
  474. a220 1
  475.         indexInfoPtr->firstBlockPtr = (Address) NIL;
  476. d229 1
  477. a229 2
  478.         indexInfoPtr->blockAddr = *(int *) (secondBlockBuffer + 
  479.                 sizeof(int) * indexInfoPtr->secondIndex);
  480. @
  481.